MMA68xx.c

Go to the documentation of this file.

#include "derivative.h"
#include "utils.h" /* For Parity */
#include "MMA68xx.h"
#include "DSPI.h"
#include "MailScheduler.h"
#include <limits.h> /* To set limits */
#include <stdlib.h>
/*
 ******************************************************************************
 * constants
 ******************************************************************************
 */
const uint16_t cau16MMA6800Reset[] =
{
  /* Sequence below is needed to perform a soft-reset */
  (MMA6800_DEVCTL | (MMA6800_WRITE_REGISTER << CHAR_BIT) | CLEAR),
  (MMA6800_DEVCTL | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0xC0u),
  (MMA6800_DEVCTL | (MMA6800_WRITE_REGISTER << CHAR_BIT) | 0x40u),
  /* Dummy read after reset */
  (MMA6800_DEVCFG | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR),
  (MMA6800_DEVCFG | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR) };

const uint16_t cau16MMA6800ReadAllRegisters[] =
{
  (MMA6800_SN0 | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN1
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN2
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN3
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_FCTCFG_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_FCTCFG_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_PN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCTL
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMCFGX
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMCFGY
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_XP
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_YP
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_XN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_YN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVSTAT
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_COUNT
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_OFF_CORR_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_OFF_CORR_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR) };

const uint16_t cau16MMA6500ReadAllRegisters[] =
{
  (MMA6800_SN0 | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN1
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN2
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_SN3
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_STDEFL_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_STDEFL_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_FCTCFG_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_FCTCFG_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_PN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCTL
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVCFG_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMCFGX
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMCFGY
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_XP
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_YP
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_XN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_ARMT_YN
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_DEVSTAT
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_COUNT
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_OFF_CORR_X
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR), (MMA6800_OFF_CORR_Y
      | (MMA6800_READ_REGISTER << CHAR_BIT) | CLEAR) };

/* Constant table below groups all possible acceleration modes for each */
/* sensor.                                                              */
const uint16_t cau16MMA6800PerformAccelReading[] =
{
  /* Config 0 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_SIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_SIGNED_DATA | MMA6800_ARM_DISABLE),
  /* Config 1 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_SIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_SIGNED_DATA | MMA6800_ARM_ENABLE),
  /* Config 2 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),
  /* Config 3 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED\

      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),
  /* Config 4 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_DISABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_DISABLE),
  /* Config 5 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_ENABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_ENABLE),
  /* Config 6 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),
  /* Config 7 */
  (MMA6800_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6800_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE), };

const uint16_t cau16MMA6500PerformAccelReading[] =
{
  /* Config 0 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_SIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_SIGNED_DATA | MMA6800_ARM_DISABLE),

  /* Config 1 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_SIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_SIGNED_DATA | MMA6800_ARM_ENABLE),

  /* Config 2 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  /* Config 3 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_OFFSET_CANCELLED
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),

  /* Config 4 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_DISABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_DISABLE),

  /* Config 5 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_ENABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA | MMA6800_SIGNED_DATA
      | MMA6800_ARM_ENABLE),

  /* Config 6 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_DISABLE),

  /* Config 7 */
  (MMA6500_READ_ACCEL | MMA6800_X_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE),

  (MMA6500_READ_ACCEL | MMA6800_Y_AXIS | MMA6800_RAW_DATA
      | MMA6800_UNSIGNED_DATA | MMA6800_ARM_ENABLE), };

/* The element below is a constant array of pointers to functions    */
/* with two elements, namely the address of the scheduled and the    */
/* immediate transfers. This solution allows the user to send either */
/* command just by choosing the index in the array.                  */
uint8_t (* const u8pfnMMA6800BatchOp[])(const uint8_t cu8DSPIInstance,
                                        const uint8_t cu8ChipSelect,
                                        const uint16_t* pu16DataToSend,
                                        uint16_t* pu16UnfilteredDataReceived,
                                        uint8_t u8Size) =

{
  &u8fnMMA6800ScheduledBatchOp, &u8fnMMA6800BatchOp };
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
/* Global variable array that allows "trash" responses to be scheduled safely*/
uint8_t gau8MMA6800GlobalResult[MMA6800_GLOBAL_BUFFER_SIZE];
/*
 ******************************************************************************
 * u8fnMMA6800ReadRegister
 ******************************************************************************
 */
uint8_t u8fnMMA6800ReadRegister(const uint8_t cu8DSPIInstance,
                                const uint8_t cu8ChipSelect,
                                const uint8_t cu8TransferMode,
                                uint16_t u16Register, uint16_t* pu16DataRead)
{
  uint16_t u16ReadCmd;
  
  /* Create data to be sent in the correct format */
  u16ReadCmd = (uint16_t)((MMA6800_READ_REGISTER << 8u) | u16Register);
  
  /* Call the correct fn according to cu8TransferMode */
  return ((*u8pfnMMA6800BatchOp[cu8TransferMode])(cu8DSPIInstance,
                                                  cu8ChipSelect,
                                                  (uint16_t*)&u16ReadCmd,
                                                  pu16DataRead, 1u));
}
/*
 ******************************************************************************
 * u8fnMMA6800WriteRegister
 ******************************************************************************
 */
uint8_t u8fnMMA6800WriteRegister(const uint8_t cu8DSPIInstance,
                                 const uint8_t cu8ChipSelect,
                                 const uint8_t cu8TransferMode,
                                 uint16_t u16Register, uint8_t u8ValueToWrite,
                                 uint16_t* pu16DataRead)
{
  uint16_t u16WriteCmd;
  
  u16WriteCmd = (uint16_t)((MMA6800_WRITE_REGISTER << 8u) | u16Register
      | u8ValueToWrite);
  
  /* Call the correct fn according to cu8TransferMode */
  return ((*u8pfnMMA6800BatchOp[cu8TransferMode])(cu8DSPIInstance,
                                                  cu8ChipSelect,
                                                  (uint16_t*)&u16WriteCmd,
                                                  pu16DataRead, 1u));
}
/*
 ******************************************************************************
 * u8fnMMA6800Reset
 ******************************************************************************
 */
uint8_t u8fnMMA6800Reset(const uint8_t cu8DSPIInstance,
                         const uint8_t cu8ChipSelect,
                         const uint8_t cu8TransferMode)
{
  
  /* Call the correct fn according to cu8TransferMode */
  return ((*u8pfnMMA6800BatchOp[cu8TransferMode])(cu8DSPIInstance,
                                                  cu8ChipSelect,
                                                  (uint16_t*)cau16MMA6800Reset,
                                                  (uint16_t*)gau8MMA6800GlobalResult,
                                                  (uint8_t)N_ELEMENTS(cau16MMA6800Reset)));
}
/*
 ******************************************************************************
 * u8fnMMA6800ReadAccel
 ******************************************************************************
 */
uint8_t u8fnMMA6800ReadAccel(const uint8_t cu8DSPIInstance,
                             const uint8_t cu8ChipSelect,
                             const uint8_t cu8TransferMode,
                             const uint8_t cu8Axis,
                             const uint8_t cu8ConfigMemory,
                             uint16_t* pu16AccelResults, const uint8_t cu8Accel)
{
  /* Declare locals */
  uint8_t u8Index;
  uint8_t u8Status;
  uint8_t u8Counter;
  uint8_t u8Offset;
  uint16_t* pu16AccelTable;
  
  /* Init locals */
  u8Status = CLEAR;
  u8Index = CLEAR;
  u8Offset = CLEAR;
  u8Counter = (uint8_t)1u;
  pu16AccelTable = (uint16_t*)&cau16MMA6800PerformAccelReading;
  
  /* Figure out where in the table we are */
  if(cu8ConfigMemory >= (N_ELEMENTS(cau16MMA6800PerformAccelReading) / 2u))
  {
    /* This is bad - we are out of the table. flag it as an error and exit */
    u8Status = MMA6800_INVALID_MEMORY_LOCATION;
  }
  else
  {
    /* Figure out how many readings we need - this will change the offset */
    /* within the table */
    if(MMA6800_READ_X & cu8Axis)
    {
      if(MMA6800_READ_Y & cu8Axis)
      {
        u8Counter++;
      }
      else
      {
        /* Nothing */
      }
    }
    else if(MMA6800_READ_Y & cu8Axis)
    {
      u8Offset++;
    }
    else
    {
      /* Nothing */
    }

    /* Here, we'll calculate the index for the table based on the above */
    /* operations.                                                      */
    u8Index = (uint8_t)((uint8_t)2u * cu8ConfigMemory) + u8Offset;
    
    /* Depending on what type of accelerometer is the type of request   */
    /* that we will be performing.                                      */
    if(MESQUITE == cu8Accel)
    {
      pu16AccelTable = (uint16_t*)&cau16MMA6800PerformAccelReading[u8Index];
    }
    else if(SYCAMORE == cu8Accel)
    {
      pu16AccelTable = (uint16_t*)&cau16MMA6500PerformAccelReading[u8Index];
      
    }
    else
    {
      /* Accelerometer is not defined */
      u8Status = MMA6800_ERROR_ACCEL;
    }

    /* Perform the transfer, either automatically or scheduled */
    u8Status
        = (*u8pfnMMA6800BatchOp[cu8TransferMode])(cu8DSPIInstance,
                                                  cu8ChipSelect,
                                                  (const uint16_t*)pu16AccelTable,
                                                  pu16AccelResults, u8Counter);
    
    if(MMA6800_TRANSFER_MODE_IS_IMMEDIATE == cu8TransferMode)
    {
      u8Status |= u8fnMMA6800ExtractAccelResponse(pu16AccelResults,
                                                  pu16AccelResults, u8Counter,
                                                  cu8Accel);
    }
    else
    {
      /* We are done */
    }
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMMA6800ExtractRegisterResponse
 ******************************************************************************
 */
uint8_t u8fnMMA6800ExtractRegisterResponse(const uint16_t* pu16RawResponse,
                                           uint8_t* pu8Response, 
                                           uint8_t u8Size)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t u8Counter;
  
  /* Init local variables */
  u8Status = CLEAR;
  u8Counter = CLEAR;
  
  for(; u8Counter < u8Size; u8Counter++)
  {
    /* Check Parity */
    if(CLEAR == u16fnCheckOddParity(*pu16RawResponse, CLEAR))
    {
      /* Is this a register operation? */
      u8Status |= u8fnMMA6800ResponseAnalysis(*pu16RawResponse);
      if(MMA6800_REGISTER_RESPONSE == u8Status)
      {
        u8Status = CLEAR;
        *pu8Response = (uint8_t)*pu16RawResponse;
      }
      else
      {
        *pu8Response = CLEAR;
      }

    }
    else
    {
      /* If invalid parity is found, clear this particular response, */
      /* and make sure to flag it in the status byte.                */
      u8Status |= MMA6800_INVALID_PARITY;
      *pu8Response = CLEAR;
    }

    pu16RawResponse++;
    pu8Response++;
  }
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMMA6800ExtractAccelResponse
 ******************************************************************************
 */
uint8_t u8fnMMA6800ExtractAccelResponse(const uint16_t* pu16RawResponse,
                                        uint16_t* pu16Response, 
                                        uint8_t u8Size,
                                        const uint8_t cu8Accel)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t u8Counter;
  
  /* Init local variables */
  u8Status = CLEAR;
  u8Counter = CLEAR;
  
  for(; u8Counter < u8Size; u8Counter++)
  {
    /* Check Parity */
    if(CLEAR == u16fnCheckOddParity(*pu16RawResponse, CLEAR))
    {
      /* Is this a register operation? */
      u8Status = u8fnMMA6800ResponseAnalysis(*pu16RawResponse);
      if(MMA6800_ACCEL_READING == u8Status)
      {
        u8Status = CLEAR;
        if (MESQUITE == cu8Accel)
        {
          *pu16Response = *pu16RawResponse & MMA6800_RAW_ACCEL_MASK;
        }
        else if (SYCAMORE == cu8Accel)
        {
          *pu16Response = *pu16RawResponse & MMA6500_RAW_ACCEL_MASK;
          /* Format the 12-bits word with D0 in LSB and D11 in BIT12 location*/
          *pu16Response = (((0xC000u & *pu16Response) >> 14) | (*pu16Response << 2));
        }
        else
        {
          /* Accelerometer is not defined */
          u8Status = MMA6800_ERROR_ACCEL;
        }
      }
      else
      {
        *pu16Response = 0xFC00;
      }

    }
    else
    {
      /* If invalid parity is found, clear this particular response, */
      /* and make sure to flag it in the status byte.                */
      u8Status |= MMA6800_INVALID_PARITY;
      *pu16Response = 0xFC00;
    }

    pu16RawResponse++;
    pu16Response++;
  }
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMMA6800ResponseAnalysis
 ******************************************************************************
 */
static uint8_t u8fnMMA6800ResponseAnalysis(uint16_t u16RawResponse)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init local variables */
  u8Status = CLEAR;
  
  if(MMA6800_REGISTER_RESP_SIGNATURE == ((BIT11 | BIT10) & u16RawResponse))
  {
    /* This datagram is either a message or an error */
    u8Status = u8fnMMA6800ErrorResponseAnalysis(u16RawResponse);
    
    if(CLEAR == u8Status)
    {
      u8Status = MMA6800_REGISTER_RESPONSE;
    }
    else
    {
      /* Report the status byte provided by the called routine */
    }
  }
  else
  {
    /* This message is likely an accel reading */
    u8Status = MMA6800_ACCEL_READING;
  }
  
  return (u8Status);
  
}
/*
 ******************************************************************************
 * u8fnMMA6800ErrorResponseAnalysis
 ******************************************************************************
 */
static uint8_t u8fnMMA6800ErrorResponseAnalysis(const uint16_t cu16ReceivedWord)
{
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
  /* Once data has been received, check its integrity, starting with     */
  /* parity */
  if(CLEAR == u16fnCheckOddParity(cu16ReceivedWord, CLEAR))
  {
    /* Identify if error or register operation */
    if((CLEAR == (BIT14 & cu16ReceivedWord)) || (CLEAR == ((BIT13 | BIT9)
        & cu16ReceivedWord)))
    {
      /* Error must be reported */
      u8Status = MMA6800_ERROR_DATAGRAM;
    }
    else
    {
      /* We're good! */
    }
  }
  else
  {
    u8Status = MMA6800_INVALID_PARITY;
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u16fnMMA6800AddParityToCommand
 ******************************************************************************
 */
static uint16_t u16fnMMA6800AddParityToCommand(uint16_t u16RawCommand)
{
  uint16_t u16Command;
  
  u16Command = CLEAR;
  
  if(u16RawCommand & BIT13)
  {
    /* This is an acceleration request - parity bit is set at the end of   */
    /* datagram. Refer to spec for more info.                              */
    u16Command = u16fnCheckOddParity(u16RawCommand, BIT0);
  }
  else
  {
    /* This is a register operation. Parity bit is set in MSB. Refer to    */
    /* spec for more info.                                                 */
    u16Command = u16fnCheckOddParity(u16RawCommand, BIT15);
  }
  
  return (u16Command);
}
/*
 ******************************************************************************
 * u8fnMMA6800ScheduledBatchOp
 ******************************************************************************
 */
uint8_t u8fnMMA6800ScheduledBatchOp(const uint8_t cu8DSPIInstance,
                                    const uint8_t cu8ChipSelect,
                                    const uint16_t* pu16DataToSend,
                                    uint16_t* pu16UnfilteredDataReceived,
                                    uint8_t u8Size)
{
  uint8_t u8Status;
  uint16_t u16Counter;
  uint16_t au16CurrentWordsToSend[MMA6800_MSG_BUFFER_SIZE];
  
  /* Init locals */
  u8Status = CLEAR;
  u16Counter = CLEAR;
  
  /* Next, we shall send the rest of the datagram and store the read-back    */
  for(u16Counter = CLEAR; u16Counter < u8Size; u16Counter++)
  {
    /* Check parity. */
    au16CurrentWordsToSend[u16Counter] =
      u16fnMMA6800AddParityToCommand(*(pu16DataToSend++));
  }
  /* Write a dummy to recoup the last response */
  au16CurrentWordsToSend[u16Counter]
      = u16fnMMA6800AddParityToCommand(MMA6800_SN0);
  
  /* We must wait for the previous transmission to end before launching  */
  /* a new one. We must also make sure we don't stay here forever.       */

  /* If we came out of the above wait without expiring the timer, we     */
  /* should continue. otherwise, flag as an error.                       */
  u8Status = u8fnSchedDSPIMailTransfer(cu8DSPIInstance, cu8ChipSelect, CLEAR,
                                       CLEAR,
                                       (uint16_t*)au16CurrentWordsToSend,
                                       pu16UnfilteredDataReceived,
                                       (uint16_t)(u8Size + 1u));
  
  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMMA6800BatchOp
 ******************************************************************************
 */
uint8_t u8fnMMA6800BatchOp(const uint8_t cu8DSPIInstance,
                           const uint8_t cu8ChipSelect,
                           const uint16_t* pu16DataToSend,
                           uint16_t* pu16UnfilteredDataReceived, uint8_t u8Size)
{
  uint8_t u8Status;
  uint16_t u16Counter;
  uint16_t u16TimeOut;
  uint16_t u16CurrentWordToSend;
  uint16_t u16FirstWordReceived;
  
  /* Init locals */
  u8Status = CLEAR;
  u16Counter = CLEAR;
  u16TimeOut = CLEAR;
  u16CurrentWordToSend = CLEAR;
  u16FirstWordReceived = CLEAR;
  
  /* Use DSPI to send config - we need to send one more word since the result*/
  /* will be sent with the second one. The content of the last word is       */
  /* irrelevant.                                                             */

  /* First, send the first word and simply ignore whatever is received */
  /* Check parity. */
  u16CurrentWordToSend = u16fnMMA6800AddParityToCommand(*(pu16DataToSend++));
  u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,
                                (uint16_t*)&u16CurrentWordToSend,
                                (uint16_t*)&u16FirstWordReceived, 1u);
  
  /* Next, we shall send the rest of the datagram and store the read-back    */
  for(u16Counter = 1u; u16Counter < u8Size; u16Counter++)
  {
    /* Only proceed if we are clear to go */
    if(CLEAR == u8Status)
    {
      /* Check parity. */
      u16CurrentWordToSend = u16fnMMA6800AddParityToCommand(*(pu16DataToSend++));

      /* We must wait for the previous transmission to end before launching  */
      /* a new one. We must also make sure we don't stay here forever.       */
      u16TimeOut = CLEAR;
      while((u8fnIsDSPIBusy(cu8DSPIInstance >> 4u)) &&
          (USHRT_MAX > u16TimeOut))
      {
        u16TimeOut++;
      }

      /* If we came out of the above wait without expiring the timer, we     */
      /* should continue. otherwise, flag as an error.                       */
      if((USHRT_MAX) > u16TimeOut)
      {
        u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,
            (uint16_t*)&u16CurrentWordToSend,
            pu16UnfilteredDataReceived++, 1u);
      }
      else
      {
        /* There's something wrong */
        u8Status = MMA6800_TIMED_OUT;
      }
    }
    else
    {
      /* Loop til we exit */
    }
  }

  /* Only go on if we still can */
  if(CLEAR == u8Status)
  {
    /* Dummy write just to get the last response */
    /* Check parity. */
    u16CurrentWordToSend = u16fnMMA6800AddParityToCommand(MMA6800_SN0);
    
    /* If we came out of the above wait without expiring the timer, we       */
    /* should continue. otherwise, flag as an error.                         */
    u16TimeOut = CLEAR;
    while((u8fnIsDSPIBusy(cu8DSPIInstance >> 4u)) && (USHRT_MAX > u16TimeOut))
    {
      u16TimeOut++;
    }
    /* If we came out of the above wait without expiring the timer, we       */
    /* should continue. otherwise, flag as an error.                         */
    if((USHRT_MAX) > u16TimeOut)
    {
      u8Status = u8fnDSPITranscieve(cu8DSPIInstance, cu8ChipSelect,
                                    (uint16_t*)&u16CurrentWordToSend,
                                    pu16UnfilteredDataReceived, 1u);
    }
    else
    {
      /* There's something wrong */
      u8Status = MMA6800_TIMED_OUT;
    }
  }
  else
  {
    /* Just get out of here please */
  }
  
  return (u8Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */